diff --git a/user_guide/helpers/string_helper.html b/user_guide/helpers/string_helper.html
index cf68717..c20c7b8 100644
--- a/user_guide/helpers/string_helper.html
+++ b/user_guide/helpers/string_helper.html
@@ -123,8 +123,8 @@
 <p>The above would generate 30 newlines.</p>
 <h2>reduce_double_slashes()</h2>
 <p>Converts double slashes in a string to a single slash, except those found in http://. Example: </p>
-<code>$string = &quot;http://www.some-site.com//index.php&quot;;<br />
-echo reduce_double_slashes($string); // results in &quot;http://www.some-site.com/index.php&quot;</code>
+<code>$string = &quot;http://www.example.com//index.php&quot;;<br />
+echo reduce_double_slashes($string); // results in &quot;http://www.example.com/index.php&quot;</code>
 <h2>trim_slashes()</h2>
 <p>Removes any leading/trailing slashes from a string. Example:<br />
     <br />
